import type { CollectConfig } from "@/type/collect";
import { normalizePrice } from "./utils";

function looseParse(str: string): any {
  // 正则匹配规则：给没有双引号的属性名加上双引号
  // 匹配模式：{或, 后面的空格 + 属性名（字母/数字/下划线） + 冒号前的空格
  const processedStr = str.replace(
    /([{,]\s*)(\w+)(\s*:)/g,
    '$1"$2"$3' // 替换为：原符号 + "属性名" + 原冒号前的空格
  );

  try {
    // 用原生JSON.parse解析处理后的字符串
    return JSON.parse(processedStr);
  } catch (error) {
    // console.error(
    //   `解析失败：${error instanceof Error ? error.message : String(error)}`
    // );
    return "";
  }
}

/**
 * 从配送信息区块中提取发货日期（shippingDate）
 * @param {HTMLElement} e - 页面根DOM元素
 * @returns {string} 发货日期（l），未获取到则返回空字符串
 */
async function getShippingDate(
  doc: Document,
  collectDeliverTimeMethod: CollectConfig["collectDeliverTimeMethod"]
) {
  let l = ""; // l 表示 shippingDate（发货日期）

  // 1. 尝试从 deliveryBlockMessage 区块直接提取
  const deliveryBlock = doc.getElementById("deliveryBlockMessage");
  const deliverySpans =
    deliveryBlock?.querySelectorAll('span[data-csa-c-type="element"]') ?? [];

  const matchContentId =
    collectDeliverTimeMethod === "nonMember"
      ? "DEXUnifiedCXPDM"
      : "DEXUnifiedCXSDM";
  for (const span of Array.from(deliverySpans)) {
    const contentId = span.getAttribute("data-csa-c-content-id");
    const deliveryTime = span.getAttribute("data-csa-c-delivery-time");
    // 匹配标识发货日期的 contentId（非会员DEXUnifiedCXPDM，会员DEXUnifiedCXSDM）
    if (contentId === matchContentId && deliveryTime) {
      l = deliveryTime; // 提取发货日期
      break; // 找到后终止循环
    }
  }

  // 2. 若直接提取失败，尝试通过脚本配置和请求补充获取
  if (!l) {
    let dcpConfig: any = null;
    const scripts = doc.querySelectorAll("script");

    // 从页面脚本中解析 dcpConfig 配置
    for (const script of Array.from(scripts)) {
      const scriptContent = script.textContent || "";
      if (scriptContent.includes("dcpConfig")) {
        // 匹配 dcpConfig 变量的JSON结构
        const configMatch = scriptContent.match(
          /var\s+dcpConfig\s*=\s*({[\s\S]*?});/
        );
        if (configMatch && configMatch[1]) {
          try {
            // 假设 a.default.parse 是JSON解析方法（如JSON.parse）
            dcpConfig = looseParse(configMatch[1]);
            break;
          } catch (err) {
            // console.error("解析 dcpConfig 失败:", err);
          }
        }
      }
    }

    // 若获取到 dcpConfig，发起请求补充提取发货日期
    if (dcpConfig) {
      try {
        // 构造请求参数（移除无关字段）
        const requestData: any = { ...dcpConfig };
        delete requestData.url;
        delete requestData.csrfToken;
        delete requestData.language;

        // 发送POST请求获取配送信息
        const response = await fetch(dcpConfig.url as string, {
          method: "POST",
          headers: {
            accept: "text/html,*/*",
            "accept-language": dcpConfig.language as string,
            "content-type": "application/json",
            "csrf-token": dcpConfig.csrfToken as string,
            "x-requested-with": "XMLHttpRequest",
          },
          body: JSON.stringify(requestData),
          mode: "cors",
          credentials: "include",
          referrer: dcpConfig.url as string,
          referrerPolicy: "strict-origin-when-cross-origin",
        });

        if (response.ok) {
          const responseData = await response.json();
          const contentHtml = responseData.content ?? "";
          // 解析返回的HTML内容（假设 o.parseHTML 是HTML解析方法）
          const parser = new DOMParser();

          const parsedDoc = parser.parseFromString(contentHtml, "text/html");
          const newDeliverySpans =
            parsedDoc?.querySelectorAll('span[data-csa-c-type="element"]') ??
            [];

          // 从返回的HTML中再次提取发货日期
          for (const span of Array.from(newDeliverySpans)) {
            const contentId = span.getAttribute("data-csa-c-content-id");
            const deliveryTime = span.getAttribute("data-csa-c-delivery-time");
            if (contentId === matchContentId && deliveryTime) {
              l = deliveryTime;
              break;
            }
          }
        }
      } catch (err) {
        // console.error("补充请求获取发货日期失败:", err);
      }
    }
  }

  return l;
}

// #region [西班牙]
// 1. 定义西班牙语月份到数字的映射（注意：Date对象月份从0开始，所以减1）
const mexMonthMap = {
  enero: 0, // 1月
  febrero: 1, // 2月
  marzo: 2, // 3月
  abril: 3, // 4月
  mayo: 4, // 5月
  junio: 5, // 6月
  julio: 6, // 7月
  agosto: 7, // 8月
  septiembre: 8, // 9月
  octubre: 9, // 10月
  noviembre: 10, // 11月
  diciembre: 11, // 12月
} as const;
type MexMonthKey = keyof typeof mexMonthMap;
function extractMexShipDeliverTime(spanishDateStr: string): number | "" {
  // 2. 提取日和月份（处理类似 "el viernes, 7 de noviembre" 的格式）
  const regex = /(\d+)\s+de\s+(\w+)/i; // 匹配 "7 de noviembre" 部分
  const match = spanishDateStr.match(regex);
  if (!match) {
    // console.error(
    //   "日期格式不正确，请使用类似 'el viernes, 7 de noviembre' 的格式"
    // );
    return "";
  }
  const day = parseInt(match[1], 10); // 提取日（7）
  const monthName = match[2].toLowerCase() as MexMonthKey; // 提取月份名称（noviembre）
  const month = mexMonthMap[monthName];

  if (month === undefined) {
    return "";
    // throw new Error("未识别的月份，请检查西班牙语月份拼写");
  }

  // 3. 补全年份（默认使用当前年份，可根据需求调整）
  const now = new Date();
  const year = now.getFullYear();

  // 4. 创建目标日期对象（时分秒设为0，避免当天内的时间差影响）
  const targetDate = new Date(year, month, day, 0, 0, 0, 0);

  // 5. 计算时间差（毫秒），转换为天数并取整
  const timeDiff = targetDate.getTime() - now.getTime();
  const daysDiff = Math.ceil(timeDiff / (1000 * 60 * 60 * 24)); // 向上取整（如需向下取整用Math.floor）

  return daysDiff;
}

// #endregion

// #region [美国/英国/加拿大]
function getDaysDifferenceUsa(dateStr: string): number | "" {
  if (dateStr.includes("Overnight")) {
    return 0;
  }
  // 1. 提取月、日（处理类似 "Monday, November 10" 的格式）
  const regex = /(\w+)\s+(\d+)/i; // 匹配 "November 10" 部分
  const match = dateStr.match(regex);
  if (!match) {
    return "";
    // throw new Error("日期格式不正确，请使用类似 'Monday, November 10' 的格式");
  }
  const monthName = match[1]; // 提取月份（November）
  const day = parseInt(match[2], 10); // 提取日（10）

  // 2. 补全年份（默认使用当前年份）
  const now = new Date();
  const year = now.getFullYear();

  // 3. 创建目标日期对象（利用Date可直接解析英语月名的特性）
  // 格式："Month Day, Year"（如 "November 10, 2025"）
  const targetDateStr = `${monthName} ${day}, ${year}`;
  const targetDate = new Date(targetDateStr);

  // 验证日期有效性（避免无效日期如 February 30）
  if (isNaN(targetDate.getTime())) {
    // console.error("无效的日期，请检查格式或数值");
    return "";
  }

  // 4. 统一时间为当天0点，避免时分秒影响计算
  targetDate.setHours(0, 0, 0, 0);
  now.setHours(0, 0, 0, 0);

  // 5. 计算天数差（毫秒转天数，取整）
  const timeDiff = targetDate.getTime() - now.getTime();
  const daysDiff = Math.ceil(timeDiff / (1000 * 60 * 60 * 24));

  return daysDiff;
}
// #endregion

// #region [日本]
function getDaysDifferenceJapanese(dateStr: string): number | "" {
  if (dateStr.includes("今日")) {
    return 0;
  }
  // 1. 提取月和日（处理类似 "11月12日 水曜日にお届け" 的格式）
  // 正则匹配 "数字月数字日" 部分（如 "11月12日"）
  const regex = /(\d+)月(\d+)日/;
  const match = dateStr.match(regex);
  if (!match) {
    // console.error(
    //   "日期格式不正确，请使用类似 '11月12日 水曜日にお届け' 的格式"
    // );
    return "";
  }
  const month = parseInt(match[1], 10) - 1; // 提取月份（11月 → 10，因Date月份从0开始）
  const day = parseInt(match[2], 10); // 提取日（12日 → 12）

  // 验证月份和日期的有效性
  if (month < 0 || month > 11) {
    // console.error("月份无效，请输入1-12之间的数字");
    return "";
  }
  if (day < 1 || day > 31) {
    // 简化验证，实际可根据月份细化（如2月最多29天）
    // console.error("日期无效，请输入1-31之间的数字");
    return "";
  }

  // 2. 补全年份（默认使用当前年份）
  const now = new Date();
  const year = now.getFullYear();

  // 3. 创建目标日期对象（时分秒设为0，避免时间差干扰）
  const targetDate = new Date(year, month, day, 0, 0, 0, 0);

  // 验证日期是否有效（例如：2月30日是无效日期）
  if (targetDate.getMonth() !== month || targetDate.getDate() !== day) {
    // console.error("无效的日期，该月份没有这一天");
    return "";
  }

  // 4. 统一当前时间为当天0点
  now.setHours(0, 0, 0, 0);

  // 5. 计算天数差（毫秒转天数，向上取整）
  const timeDiff = targetDate.getTime() - now.getTime();
  const daysDiff = Math.ceil(timeDiff / (1000 * 60 * 60 * 24));

  return daysDiff;
}
// #endregion

// #region [澳大利亚]
function getDaysDifferenceAu(dateStr: string): number | "" {
  // 定义多种日期格式的正则匹配规则，按优先级排序
  const regexPatterns = [
    // 匹配范围格式（如 "18 - 24 November"）- 优先提取起始日
    /^(\d+)\s*[-–]\s*\d+\s+(\w+)$/i,
    // 匹配范围格式（如 "28 November - 5 December"）- 优先提取起始日期
    /^(\d+)\s+(\w+)\s*[-–]\s*\d+\s+\w+$/i,
    // 匹配带星期的格式（如 "Monday, 10 November"）
    /,\s*(\d+)\s+(\w+)/i,
    // 匹配基础格式（如 "13 November"）
    /(\d+)\s+(\w+)/i,
  ];

  let day: number | undefined, monthName: string | undefined;
  let matched = false;

  // 尝试匹配不同格式
  for (const regex of regexPatterns) {
    const match = dateStr.match(regex);
    if (match) {
      // 处理"18 - 24 November"格式
      if (regexPatterns.indexOf(regex) === 0) {
        day = parseInt(match[1], 10);
        monthName = match[2];
      }
      // 处理"28 November - 5 December"格式
      else if (regexPatterns.indexOf(regex) === 1) {
        day = parseInt(match[1], 10);
        monthName = match[2];
      }
      // 处理带星期的格式
      else if (regexPatterns.indexOf(regex) === 2) {
        day = parseInt(match[1], 10);
        monthName = match[2];
      }
      // 处理基础格式
      else {
        day = parseInt(match[1], 10);
        monthName = match[2];
      }

      if (day && monthName) {
        matched = true;
        break;
      }
    }
  }

  if (!matched || day === undefined || monthName === undefined) {
    return ""; // 未匹配到有效格式
  }

  // 补全年份（使用当前年份）
  const now = new Date();
  const year = now.getFullYear();

  // 构建可被Date解析的字符串（"November 13, 2025" 格式）
  const targetDateStr = `${monthName} ${day}, ${year}`;
  const targetDate = new Date(targetDateStr);

  // 验证日期有效性
  if (isNaN(targetDate.getTime())) {
    return "";
  }

  // 统一时间为当天0点，避免时分秒影响
  targetDate.setHours(0, 0, 0, 0);
  now.setHours(0, 0, 0, 0);

  // 计算天数差（向上取整）
  const timeDiff = targetDate.getTime() - now.getTime();
  const daysDiff = Math.ceil(timeDiff / (1000 * 60 * 60 * 24));

  return daysDiff;
}
// #endregion

// #region [沙特]
// 注意：阿拉伯语月份拼写需与输入字符串完全一致（区分大小写和字符形式）
const arabicMonthMap = {
  يناير: 0, // 1月（阿拉伯语“一月”）
  فبراير: 1, // 2月
  مارس: 2, // 3月
  أبريل: 3, // 4月
  مايو: 4, // 5月
  يونيو: 5, // 6月
  يوليو: 6, // 7月
  أغسطس: 7, // 8月
  سبتمبر: 8, // 9月
  أكتوبر: 9, // 10月
  نوفمبر: 10, // 11月（对应输入中的"نوفمبر"）
  ديسمبر: 11, // 12月
} as const;
type ArabicMonthKey = keyof typeof arabicMonthMap;
function getDaysDifferenceArabic(dateStr: string): number | "" {
  try {
    // 正则优先级：先匹配范围格式，再匹配其他格式
    const regexPatterns = [
      // 1. 匹配"月份 起始日 - 结束日"（如"ديسمبر 1 - 3"或"نوفمبر ١٠ - ١٥"）
      /(\p{L}+)\s+(\d+|١|٢|٣|٤|٥|٦|٧|٨|٩|١٠|١١|١٢|١٣|١٤|١٥|١٦|١٧|١٨|١٩|٢٠|٢١|٢٢|٢٣|٢٤|٢٥|٢٦|٢٧|٢٨|٢٩|٣٠|٣١)\s*[-–]\s*(\d+|١|٢|٣|٤|٥|٦|٧|٨|٩|١٠|١١|...|٣١)/u,
      // 2. 匹配"星期， 起始日 - 结束日 月份"（如"الجمعة، ٥ - ٧ أكتوبر"）
      /(?:\p{L}+،\s*)(\d+|١|...|٣١)\s*[-–]\s*(\d+|١|...|٣١)\s+(\p{L}+)/u,
      // 3. 匹配"星期， 日 月份"（如"السبت، 8 نوفمبر"）
      /(?:\p{L}+،\s*)(\d+|١|...|٣١)\s+(\p{L}+)/u,
      // 4. 匹配基础"日 月份"（如"15 مارس"或"٢٠ أبريل"）
      /(\d+|١|...|٣١)\s+(\p{L}+)/u,
    ];

    let dayStr: string | undefined, monthName: string | undefined;
    let matched = false;

    // 遍历正则，优先匹配范围格式
    for (const regex of regexPatterns) {
      const match = dateStr.match(regex);
      if (match) {
        // 处理"月份 起始日 - 结束日"（如"ديسمبر 1 - 3"）
        if (regexPatterns.indexOf(regex) === 0) {
          monthName = match[1].trim(); // 月份（ديسمبر）
          dayStr = match[2]; // 起始日（1）
        }
        // 处理"星期， 起始日 - 结束日 月份"（如"الجمعة، ٥ - ٧ أكتوبر"）
        else if (regexPatterns.indexOf(regex) === 1) {
          dayStr = match[1]; // 起始日（٥）
          monthName = match[3].trim(); // 月份（أكتوبر）
        }
        // 处理"星期， 日 月份"（如"السبت، 8 نوفمبر"）
        else if (regexPatterns.indexOf(regex) === 2) {
          dayStr = match[1]; // 日（8）
          monthName = match[2].trim(); // 月份（نوفمبر）
        }
        // 处理基础"日 月份"
        else {
          dayStr = match[1]; // 日
          monthName = match[2].trim(); // 月份
        }

        matched = true;
        break;
      }
    }

    if (!matched || !dayStr || !monthName) {
      return ""; // 未匹配有效格式
    }

    // 转换日为英文数字（处理阿拉伯数字）
    const arabicNumbers = ["٠", "١", "٢", "٣", "٤", "٥", "٦", "٧", "٨", "٩"];
    let processedDayStr = dayStr;
    arabicNumbers.forEach((ar, idx) => {
      processedDayStr = processedDayStr.replace(
        new RegExp(ar, "g"),
        String(idx)
      );
    });
    const day = parseInt(processedDayStr, 10);
    if (isNaN(day) || day < 1 || day > 31) {
      return ""; // 无效日期
    }

    // 匹配月份
    const month = arabicMonthMap[monthName as ArabicMonthKey];
    if (month === undefined) {
      return ""; // 月份未识别
    }

    // 验证日期有效性并计算天数差
    const now = new Date();
    const year = now.getFullYear();
    const targetDate = new Date(year, month, day, 0, 0, 0, 0);
    if (targetDate.getMonth() !== month || targetDate.getDate() !== day) {
      return ""; // 无效日期（如2月30日）
    }

    now.setHours(0, 0, 0, 0);
    const timeDiff = targetDate.getTime() - now.getTime();
    const daysDiff = Math.ceil(timeDiff / (1000 * 60 * 60 * 24));

    return daysDiff;
  } catch (error) {
    return "";
  }
}
// #endregion

// #region [德国]
// 德语月名到数字的映射（避免不同环境对德语月名解析差异）
const germanyMonthMap: Record<string, number> = {
  januar: 0,
  februar: 1,
  märz: 2,
  april: 3,
  mai: 4,
  juni: 5,
  juli: 6,
  august: 7,
  september: 8,
  oktober: 9,
  november: 10,
  dezember: 11,
};
function getDaysDifferenceGermany(dateStr: string): number | "" {
  if (dateStr.includes("Übernacht")) {
    // 对应德国语境的"隔夜"情况
    return 0;
  }
  // 1. 提取日、月（处理类似 "Montag, 24. November" 的格式）
  const regex = /(\d+)\.\s+(\w+)/i; // 匹配 "24. November" 部分（数字. 月份）
  const match = dateStr.match(regex);
  if (!match) {
    return "";
  }
  const day = parseInt(match[1], 10); // 提取日（24）
  const monthName = match[2]; // 提取月份（November）

  // 2. 补全年份（默认使用当前年份）
  const now = new Date();
  const year = now.getFullYear();

  // 3. 创建目标日期对象（适配德语月名解析）
  const month = germanyMonthMap[monthName.toLowerCase()];
  if (month === undefined) {
    return ""; // 无效月份名称
  }

  // 创建日期对象（月份为数字索引，0-11）
  const targetDate = new Date(year, month, day);

  // 验证日期有效性（避免无效日期如 30. Februar）
  if (
    isNaN(targetDate.getTime()) ||
    targetDate.getDate() !== day ||
    targetDate.getMonth() !== month
  ) {
    return "";
  }

  // 4. 统一时间为当天0点，避免时分秒影响计算
  targetDate.setHours(0, 0, 0, 0);
  now.setHours(0, 0, 0, 0);

  // 5. 计算天数差（毫秒转天数，取整）
  const timeDiff = targetDate.getTime() - now.getTime();
  const daysDiff = Math.ceil(timeDiff / (1000 * 60 * 60 * 24));

  return daysDiff;
}
// #endregion

// #region [法国]
// 法语月名到数字的映射（避免环境解析差异）
const franceMonthMap: Record<string, number> = {
  janvier: 0,
  février: 1,
  mars: 2,
  avril: 3,
  mai: 4,
  juin: 5,
  juillet: 6,
  août: 7,
  septembre: 8,
  octobre: 9,
  novembre: 10,
  décembre: 11,
  // 英语月名（新增）
  january: 0,
  february: 1,
  march: 2,
  april: 3,
  may: 4,
  june: 5,
  july: 6,
  august: 7,
  september: 8,
  october: 9,
  november: 10,
  december: 11,
};
function getDaysDifferenceFrance(dateStr: string): number | "" {
  if (dateStr.includes("Une nuit")) {
    // 对应法国语境的"隔夜"情况
    return 0;
  }

  // 修改正则：匹配（星期,） 数字 月份（支持法语/英语格式）
  // 匹配模式：可选的星期（如Saturday,） + 空格 + 数字 + 空格 + 月份
  const regex = /(?:[A-Za-z]+,\s*)?(\d+)\s+([A-Za-zéûô]+)/i;
  const match = dateStr.match(regex);

  if (!match) {
    return "";
  }

  const day = parseInt(match[1], 10);
  const monthName = match[2].toLowerCase();

  // 补全年份（默认使用当前年份）
  const now = new Date();
  const year = now.getFullYear();

  // 获取月份数字（兼容法/英文）
  const month = franceMonthMap[monthName];
  if (month === undefined) {
    return ""; // 无效月份名称
  }

  // 创建目标日期对象（月份为数字索引，0-11）
  const targetDate = new Date(year, month, day);

  // 验证日期有效性（避免自动进位问题，如31 avril会转为1 mai）
  if (
    isNaN(targetDate.getTime()) ||
    targetDate.getDate() !== day ||
    targetDate.getMonth() !== month
  ) {
    return "";
  }

  // 统一时间为当天0点，避免时分秒影响计算
  targetDate.setHours(0, 0, 0, 0);
  now.setHours(0, 0, 0, 0);

  // 计算天数差（毫秒转天数，取整）
  const timeDiff = targetDate.getTime() - now.getTime();
  const daysDiff = Math.ceil(timeDiff / (1000 * 60 * 60 * 24));

  return daysDiff;
}
// #endregion

// #region [获取到货时间]
async function getShipDeliverTime({
  doc,
  marketplace,
  collectDeliverTimeMethod,
}: {
  doc: Document;
  marketplace: string;
  collectDeliverTimeMethod: CollectConfig["collectDeliverTimeMethod"];
}): Promise<number | ""> {
  try {
    let ship_deliver_time = await getShippingDate(
      doc,
      collectDeliverTimeMethod
    );
    // console.log("ship_deliver_time", ship_deliver_time);
    if (marketplace === "USA") {
      return getDaysDifferenceUsa(ship_deliver_time);
    } else if (marketplace === "JPN") {
      return getDaysDifferenceJapanese(ship_deliver_time);
    } else if (marketplace === "MEX") {
      return extractMexShipDeliverTime(ship_deliver_time);
    } else if (marketplace === "AUS") {
      return getDaysDifferenceAu(ship_deliver_time);
    } else if (marketplace === "SAU") {
      return getDaysDifferenceArabic(ship_deliver_time);
    } else if (marketplace === "DEU") {
      return getDaysDifferenceGermany(ship_deliver_time);
    } else if (marketplace === "FRA") {
      return getDaysDifferenceFrance(ship_deliver_time);
    }
    return "";
  } catch (error) {
    // console.log("error", error);
    return "";
  }
}
// #endregion

// #region [sold_by]
// 提取 sold_by 的获取方法
function getSoldBy(doc: Document, marketplace: string) {
  // 获取包含商家信息的容器元素
  let sold_by = "";
  const merchantInfoContainer = doc.querySelector(
    "#merchantInfoFeature_feature_div"
  );
  // 从容器中获取商家信息文本，并进行格式化处理
  sold_by =
    merchantInfoContainer
      ?.querySelector(".offer-display-feature-text-message")
      ?.textContent?.replace(/\s+/g, "") // 去除所有空格
      ?.trim() || // 去除首尾空白（这里主要是兼容可能的残留空白）
    ""; // 若获取失败，默认返回空字符串

  if (!sold_by) {
    // 亚马逊二手
    const SSOFpopoverLinkElement = doc.querySelector(
      '[id^="SSOFpopoverLink_"]'
    );
    if (SSOFpopoverLinkElement) {
      sold_by = SSOFpopoverLinkElement.textContent?.trim() || "";
    }
  }

  return sold_by;
}
// #endregion

// #region [ship_from]
function getShipFrom(doc: Document, marketplace: string) {
  let ship_from = "";
  // --- 1. 提取 SHIPS FROM (发货方) ---
  try {
    // 使用 CSS 选择器定位发货方元素
    const shipsFromElement = doc.querySelector(
      "#fulfillerInfoFeature_feature_div .offer-display-feature-text-message"
    );
    if (shipsFromElement) {
      ship_from = shipsFromElement.textContent?.trim() || "";
    }
    if (!ship_from) {
      // 亚马逊二手
      const sellerProfileTriggerIdElement = doc.querySelector(
        "#sellerProfileTriggerId"
      );
      if (sellerProfileTriggerIdElement) {
        ship_from = sellerProfileTriggerIdElement.textContent?.trim() || "";
      }
    }
  } catch (e) {
    // console.error(
    //   `提取 Ships from 时发生错误: ${
    //     e instanceof Error ? e.message : String(e)
    //   }`
    // );
    // ship_from 保持为空字符串
    return "";
  }

  return ship_from;
}
// #endregion

export async function extractShippingInfo({
  doc,
  marketplace,
  collectDeliverTimeMethod,
}: {
  doc: Document;
  marketplace: string;
  collectDeliverTimeMethod: CollectConfig["collectDeliverTimeMethod"];
}): Promise<{
  shipping_fee: string;
  ship_from: string;
  ship_deliver_time: number | "";
  sold_by: string;
}> {
  let ship_deliver_time = await getShipDeliverTime({
    doc,
    marketplace,
    collectDeliverTimeMethod,
  });
  // console.log("ship_deliver_time", ship_deliver_time);
  const sold_by = getSoldBy(doc, marketplace);
  const ship_from = getShipFrom(doc, marketplace);

  // 查找包含运费信息的元素（带 data-csa-c-delivery-price 属性）
  const deliveryElement = doc.querySelector("[data-csa-c-delivery-price]");
  if (!deliveryElement && marketplace !== "FRA") {
    return {
      shipping_fee: "0",
      ship_from,
      ship_deliver_time,
      sold_by,
    };
  }

  // 获取 data-csa-c-delivery-price 属性值
  let rawFee =
    deliveryElement?.getAttribute("data-csa-c-delivery-price")?.trim() || "";

  if (!rawFee) {
    if (marketplace === "FRA") {
      // 1. 尝试从 deliveryBlockMessage 区块直接提取
      const deliveryBlock = doc.getElementById("deliveryBlockMessage");
      const aSpacingBaseElement =
        deliveryBlock?.querySelectorAll(".a-spacing-base");
      (aSpacingBaseElement || []).forEach((spacingBaseElement) => {
        const textContent = spacingBaseElement.textContent || "";
        if (textContent.includes("Livraison à")) {
          rawFee = textContent.replace("Livraison à", "").trim();
        }
      });
    }
  }
  // 判断是否为免费（FREE/GRATIS）
  const upperRawFee = rawFee.toUpperCase();
  if (
    ["FREE", "GRATIS", "مجاني", "GRATUITE", "無料"].includes(upperRawFee) ||
    rawFee === ""
  ) {
    return {
      shipping_fee: "0",
      ship_from,
      ship_deliver_time,
      sold_by,
    };
  }

  // 提取金额部分（根据不同市场处理）
  let match: RegExpMatchArray | null = null;
  switch (marketplace) {
    case "JPN":
      // 日本站点特殊处理（匹配带"料"或纯数字格式）
      match = rawFee.match(/(?:料\s*)?([\d,.]+)/);
      break;
    case "MEX":
      // 墨西哥站点特殊处理（匹配带MX$/$前缀的金额）
      match = rawFee.match(/(?:MX\$|\$)?([\d,.]+)/);
      break;
    case "DEU":
      rawFee = normalizePrice(rawFee, marketplace);
    case "FRA":
      rawFee = normalizePrice(rawFee, marketplace);
    default:
      // 其他市场匹配数字部分
      match = rawFee.match(/([\d,.]+)/);
  }

  if (!match) {
    // console.error(`无法解析运费金额: ${rawFee}`);
    return {
      shipping_fee: "0",
      ship_from,
      ship_deliver_time,
      sold_by,
    };
  }

  // 清理金额格式（移除千分位逗号）
  const feeValue = match[1].replace(/,/g, "");

  return {
    shipping_fee: feeValue,
    ship_from,
    ship_deliver_time,
    sold_by,
  };
}
